// test_api_endpoint.js
const fs = require('fs');

// 模拟 Egg.js 上下文和日志
const mockCtx = {
  logger: {
    info: console.log,
    warn: console.warn,
    error: console.error
  },
  model: {
    PurchaseOrderModel: {
      findOne: async () => null, // 模拟数据库中没有重复订单
      create: async (data) => {
        console.log('[数据库] 创建采购订单:', data.orderNumber);
        return { id: Math.floor(Math.random() * 1000), ...data };
      }
    },
    PurchaseOrderItemModel: {
      create: async (data) => {
        console.log('[数据库] 创建采购订单项:', data.productName);
        return data;
      }
    },
    PluginDataBatchModel: {
      findOrCreate: async () => [{ batchId: 'test_batch_123' }, true],
      update: async () => {}
    },
    PluginDataItemModel: {
      bulkCreate: async () => {}
    }
  },
  app: {
    redis: {
      set: async () => {}
    },
    Sequelize: {
      fn: () => {},
      col: () => {}
    }
  },
  service: {}
};

// 模拟 PurchaseOrderService
class PurchaseOrderService {
  constructor() {
    this.ctx = mockCtx;
  }

  // 检测平台类型
  detectPlatform(item) {
    const url = item.url || '';
    const host = item.request?.headers?.host || '';
    
    if (url.includes('taobao.com') || host.includes('taobao.com')) {
      return 'taobao';
    } else if (url.includes('jd.com') || host.includes('jd.com')) {
      return 'jd';
    } else if (url.includes('1688.com') || host.includes('1688.com')) {
      return 'alibaba';
    }
    
    return 'unknown';
  }

  // 从插件数据中提取采购订单
  async extractPurchaseOrderFromPluginData(item) {
    const { ctx } = this;
    
    try {
      ctx.logger.info('[PluginData] 开始提取采购订单数据:', item.url);
      
      // 检查数据结构
      if (!item || !item.response || !item.response.data) {
        ctx.logger.warn('[PluginData] 插件数据格式不正确，缺少response.data');
        return { success: false, error: '数据格式不正确' };
      }
      
      // 根据平台类型解析数据
      const platform = this.detectPlatform(item);
      let orders = [];
      
      if (platform === 'taobao') {
        orders = this.extractTaobaoPurchaseOrders(item);
      } else if (platform === 'jd') {
        orders = this.extractJdPurchaseOrders(item);
      } else if (platform === 'alibaba') {
        orders = this.extractAlibabaPurchaseOrders(item);
      } else {
        ctx.logger.warn('[PluginData] 未知平台的采购订单数据');
        return { success: false, error: '未知平台的采购订单数据' };
      }
      
      if (!orders || orders.length === 0) {
        ctx.logger.warn('[PluginData] 未提取到采购订单数据');
        return { success: false, error: '未提取到采购订单数据' };
      }
      
      // 保存订单数据到数据库
      const savedOrders = [];
      for (const order of orders) {
        try {
          // 检查订单是否已存在
          const existingOrder = await ctx.model.PurchaseOrderModel.findOne({
            where: { orderNumber: order.orderNumber }
          });
          
          if (existingOrder) {
            ctx.logger.info(`[PluginData] 采购订单已存在，跳过: ${order.orderNumber}`);
            continue;
          }
          
          // 保存订单主表
          const savedOrder = await ctx.model.PurchaseOrderModel.create({
            orderNumber: order.orderNumber,
            supplierId: order.supplierId || 1, // 默认供应商ID
            purchaser: order.purchaser || '系统导入',
            orderDate: order.orderDate,
            expectedDeliveryDate: order.expectedDeliveryDate,
            totalAmount: order.totalAmount,
            status: 'pending',
            remark: order.remark || '',
            organizationId: 1, // 默认组织ID
            createdAt: new Date(),
            updatedAt: new Date()
          });
          
          // 保存订单明细
          for (const orderItem of order.items) {
            await ctx.model.PurchaseOrderItemModel.create({
              orderId: savedOrder.id,
              productId: orderItem.productId || null,
              productName: orderItem.productName,
              specification: orderItem.specification || '',
              quantity: orderItem.quantity,
              unit: orderItem.unit || '件',
              unitPrice: orderItem.unitPrice,
              amount: orderItem.amount,
              remark: orderItem.remark || '',
              createdAt: new Date(),
              updatedAt: new Date()
            });
          }
          
          savedOrders.push(savedOrder);
        } catch (saveError) {
          ctx.logger.error(`[PluginData] 保存采购订单失败: ${order.orderNumber}`, saveError);
        }
      }
      
      ctx.logger.info(`[PluginData] 采购订单数据提取完成 - 成功保存: ${savedOrders.length} 条`);
      
      return {
        success: true,
        orderCount: savedOrders.length
      };
    } catch (error) {
      ctx.logger.error('[PluginData] 提取采购订单数据失败:', error);
      return { success: false, error: error.message };
    }
  }

  // 提取淘宝采购订单数据
  extractTaobaoPurchaseOrders(item) {
    const { ctx } = this;
    const orders = [];
    
    try {
      // 解析响应数据 - 注意数据在 response.data.data 中
      const responseData = item.response.data.data;
      
      // 遍历所有订单容器
      for (const key in responseData) {
        if (key.startsWith('shopOrderContainer_')) {
          const orderId = key.split('_')[1];
          
          // 获取订单信息
          const shopInfo = responseData[`shopInfo_${orderId}`];
          const orderPayment = responseData[`orderPayment_${orderId}`];
          
          if (!shopInfo || !orderPayment) {
            continue;
          }
          
          // 解析订单基本信息
          const orderDate = new Date(shopInfo.fields.createTime);
          const totalAmount = parseFloat(orderPayment.fields.actualFee.value.replace('￥', '')) || 0;
          
          // 创建订单对象
          const order = {
            orderNumber: orderId, // 订单号
            supplierId: 1, // 供应商ID（需要根据店铺信息匹配，这里暂时设为1）
            purchaser: '系统导入', // 采购员
            orderDate: orderDate, // 下单日期
            expectedDeliveryDate: null, // 预计交货日期
            totalAmount: totalAmount, // 实付款
            remark: `淘宝进货单 - ${shopInfo.fields.shopName}`, // 备注
            items: []
          };
          
          // 解析订单项 - 使用正确的模式 orderItemInfo_{orderId}_{subOrderId}
          for (const itemKey in responseData) {
            if (itemKey.startsWith(`orderItemInfo_${orderId}_`)) {
              const itemInfo = responseData[itemKey];
              const itemData = itemInfo.fields.item;
              
              // 解析商品信息
              const price = parseFloat(itemData.priceInfo.actualTotalFee.replace('￥', '')) || 0;
              const quantity = parseInt(itemData.quantity) || 0;
              const amount = price * quantity;
              
              // 合并规格信息
              let specification = '';
              if (itemData.skuInfo && Array.isArray(itemData.skuInfo)) {
                specification = itemData.skuInfo.map(sku => sku.skuValue).join(';');
              }
              
              order.items.push({
                productId: null, // 产品ID
                productName: itemData.title, // 品名
                specification: specification, // 规格
                quantity: quantity, // 数量
                unit: '件', // 单位
                unitPrice: price, // 价格
                amount: amount, // 金额
                remark: '' // 备注
              });
            }
          }
          
          // 如果有订单项，则添加到订单列表
          if (order.items.length > 0) {
            orders.push(order);
          }
        }
      }
      
      ctx.logger.info(`[PluginData] 成功提取 ${orders.length} 条淘宝采购订单数据`);
      return orders;
    } catch (error) {
      ctx.logger.error('[PluginData] 提取淘宝采购订单数据失败:', error);
      return [];
    }
  }
  
  // 提取京东采购订单数据
  extractJdPurchaseOrders(item) {
    const { ctx } = this;
    ctx.logger.info('[PluginData] 提取京东采购订单数据');
    // TODO: 实现京东采购订单数据提取逻辑
    return [];
  }
  
  // 提取阿里巴巴采购订单数据
  extractAlibabaPurchaseOrders(item) {
    const { ctx } = this;
    ctx.logger.info('[PluginData] 提取阿里巴巴采购订单数据');
    // TODO: 实现阿里巴巴采购订单数据提取逻辑
    return [];
  }
}

// 模拟 PluginDataService
class PluginDataService {
  constructor() {
    this.ctx = mockCtx;
    this.ctx.service.purchaseOrderService = new PurchaseOrderService();
  }

  // 处理订单数据
  async processOrderData(dataItems, orderType) {
    const { ctx } = this;
    
    try {
      // 获取采购订单服务
      const purchaseOrderService = ctx.service.purchaseOrderService;
      
      // 处理每个订单数据项
      for (const item of dataItems) {
        if (orderType === 'purchase_order') {
          ctx.logger.info('[PluginData] 开始处理采购订单数据:', item.url);
          
          // 采购订单处理逻辑
          const result = await purchaseOrderService.extractPurchaseOrderFromPluginData(item);
          
          if (result && result.success) {
            ctx.logger.info(`[PluginData] 采购订单数据处理成功 - 处理数量: ${result.orderCount}`);
          } else if (result) {
            ctx.logger.warn('[PluginData] 采购订单数据处理失败:', result.error);
          }
        }
      }
    } catch (error) {
      ctx.logger.error('[PluginData] 处理订单数据失败:', error);
      throw error;
    }
  }

  // 处理插件发送的数据
  async processPluginData(pluginData) {
    const { ctx } = this;
    const { batchId, timestamp, dataType, data } = pluginData;
    
    try {
      // 记录处理开始时间
      const startTime = Date.now();
      ctx.logger.info(`[PluginData] 开始处理插件数据 - 批次ID: ${batchId}, 数据类型: ${dataType}, 条数: ${data.length}`);
      
      // 保存批次信息到数据库
      const batchRecord = await ctx.model.PluginDataBatchModel.findOrCreate({
        where: { batchId: batchId },
        defaults: {
          batchId: batchId,
          dataType: dataType,
          count: data.length,
          status: 'pending',
          processedCount: 0,
          failedCount: 0,
          createdAt: new Date(),
          updatedAt: new Date()
        }
      });
      
      // 保存数据项到数据库
      const itemsToSave = data.map(item => ({
        itemId: item.id || `item_${Date.now()}_${Math.random()}`,
        batchId: batchId,
        url: item.url,
        method: item.method,
        category: dataType,
        status: 'pending',
        requestData: item.request,
        responseData: item.response,
        ruleInfo: item.ruleInfo,
        createdAt: new Date(),
        updatedAt: new Date()
      }));
      
      // 批量插入数据项
      await ctx.model.PluginDataItemModel.bulkCreate(itemsToSave, {
        ignoreDuplicates: true // 忽略重复项
      });
      
      // 根据数据类型调用相应的服务处理
      if (dataType === 'purchase_order') {
        await this.processOrderData(data, dataType);
      }
      
      const endTime = Date.now();
      const processingTime = endTime - startTime;
      
      // 更新批次处理时间
      await ctx.model.PluginDataBatchModel.update({
        processingTime: processingTime
      }, {
        where: { batchId: batchId }
      });
      
      ctx.logger.info(`[PluginData] 插件数据初步处理完成 - 批次ID: ${batchId}, 处理时间: ${processingTime}ms`);
      
      return {
        processedCount: data.length,
        processingTime: processingTime,
        batchId: batchId
      };
    } catch (error) {
      ctx.logger.error('[PluginData] 处理插件数据失败:', error);
      
      // 记录错误信息到批次记录
      await ctx.model.PluginDataBatchModel.update({
        status: 'failed',
        errorMessage: error.message
      }, {
        where: { batchId: batchId }
      });
      
      throw error;
    }
  }
}

// 模拟控制器
class PluginDataController {
  constructor() {
    this.ctx = mockCtx;
    this.ctx.service.pluginDataService = new PluginDataService();
  }

  // 接收插件发送的数据
  async receiveData() {
    const { ctx } = this;
    
    // 读取淘宝进货单数据文件
    const taobaoData = JSON.parse(fs.readFileSync('./通过插件拦截响应数据（淘宝进货单）.md', 'utf8'));
    
    const { batchId, timestamp, dataType, data } = taobaoData;
    
    try {
      // 记录接收到的数据
      ctx.logger.info(`[PluginData] 接收到插件数据 - 批次ID: ${batchId}, 数据类型: ${dataType}, 条数: ${data.length}`);
      
      // 调用服务处理数据
      const result = await ctx.service.pluginDataService.processPluginData({
        batchId,
        timestamp,
        dataType,
        data
      });
      
      console.log({
        receivedCount: data.length,
        processedCount: result.processedCount,
        batchId: batchId
      });
    } catch (error) {
      ctx.logger.error('[PluginData] 处理插件数据失败:', error);
      console.error('服务器内部错误: ' + error.message);
    }
  }
}

// 创建控制器实例并测试API端点
const controller = new PluginDataController();
controller.receiveData();